home *** CD-ROM | disk | FTP | other *** search
/ MACD 5 / MACD 5.bin / workbench / boot / czesc_2 / toolmanager / source / prefs / main.c < prev    next >
C/C++ Source or Header  |  1993-05-15  |  14KB  |  550 lines
  1. /*
  2.  * main.c  V2.1
  3.  *
  4.  * configuration program main entry point
  5.  *
  6.  * (c) 1990-1993 Stefan Becker
  7.  */
  8.  
  9. #include "ToolManagerConf.h"
  10.  
  11. static const char Version[]="\0$VER: ToolManager " TMVERSION "." TMREVISION
  12.                             " (" __COMMODORE_DATE__ ")\r\n";
  13. static const char PrefsPortName[]="ToolManager_Prefs";
  14.  
  15. /* Misc. data */
  16. struct Library *IFFParseBase=NULL;
  17. static struct MsgPort *PrefsPort=NULL;
  18. static char *FromFileName;
  19. static char *PubScreenName;
  20. static char Template[]="FROM,EDIT/S,USE/S,SAVE/S,PUBSCREEN/K,DEFAULTFONT/S";
  21. static struct {
  22.                char *from;
  23.                long  edit;
  24.                long  use;
  25.                long  save;
  26.                char *pubsc;
  27.                long  deffont;
  28.               } cmdlineparams={PrefsFileName,TRUE,FALSE,FALSE,NULL,FALSE};
  29. static UWORD MainWinX=10;
  30. static UWORD MainWinY=10;
  31. static BOOL DefaultFont;
  32. static char WBName[]="Workbench";
  33. static char YesString[]="Y|Yes";
  34.  
  35. /* Open resources */
  36. static BOOL OpenResources(void)
  37. {
  38.  if (!(IFFParseBase=OpenLibrary("iffparse.library",37))) return(FALSE);
  39.  if (!(PrefsPort=CreateMsgPort())) return(FALSE);
  40.  PrefsPort->mp_Node.ln_Pri=-127;
  41.  PrefsPort->mp_Node.ln_Name=PrefsPortName;
  42.  AddPort(PrefsPort);
  43.  
  44.  /* Try to open workbench.library */
  45.  WorkbenchBase=OpenLibrary("workbench.library",37);
  46.  
  47.  if (!(AppMsgPort=CreateMsgPort())) return(FALSE);
  48.  GetLocale();
  49.  
  50.  /* All OK */
  51.  return(TRUE);
  52. }
  53.  
  54. /* Close Resources */
  55. static void CloseResources(void)
  56. {
  57.  FreeLocale();
  58.  if (AppMsgPort) {
  59.   struct Message *msg;
  60.   while (msg=GetMsg(AppMsgPort)) ReplyMsg(msg);
  61.   DeleteMsgPort(AppMsgPort);
  62.  }
  63.  if (WorkbenchBase) CloseLibrary(WorkbenchBase);
  64.  if (PrefsPort) {
  65.   RemPort(PrefsPort);
  66.   DeleteMsgPort(PrefsPort);
  67.  }
  68.  if (IFFParseBase) CloseLibrary(IFFParseBase);
  69. }
  70.  
  71. /* Free all preferences objects */
  72. void FreeAllObjects(void)
  73. {
  74.  int i;
  75.  
  76.  for (i=0; i<TMOBJTYPES; i++) {
  77.   struct List *list=&ObjectLists[i];
  78.   FreeNodeFuncPtr freefunc=FreeNodeFunctions[i];
  79.   struct Node *node;
  80.  
  81.   /* Scan list and free nodes */
  82.   while (node=RemHead(list)) (*freefunc)(node);
  83.  }
  84. }
  85.  
  86. /* Copy a file */
  87. BOOL CopyFile(char *source, char *dest)
  88. {
  89.  char *copybuf;
  90.  BOOL rc=FALSE;
  91.  
  92.  /* Allocate copy buffer */
  93.  if (copybuf=malloc(2048)) {
  94.   BPTR infh;
  95.  
  96.   /* Open source file */
  97.   if (infh=Open(source,MODE_OLDFILE)) {
  98.    BPTR outfh;
  99.  
  100.    /* Open destination file */
  101.    if (outfh=Open(dest,MODE_NEWFILE)) {
  102.     LONG n;
  103.  
  104.     /* Copy file */
  105.     while ((n=Read(infh,copybuf,2048))>0) Write(outfh,copybuf,n);
  106.  
  107.     /* No error? */
  108.     if (n==0) rc=TRUE;
  109.  
  110.     Close(outfh);
  111.    }
  112.    Close(infh);
  113.   }
  114.   free(copybuf);
  115.  }
  116.  return(rc);
  117. }
  118.  
  119. /* Main program */
  120. static int mainprogram(struct WBArg *wa)
  121. {
  122.  /* Another ToolManager Preferences program already running? */
  123.  Forbid();
  124.  if (PrefsPort=FindPort(PrefsPortName)) {
  125.   /* Yes, signal other task... */
  126.   Signal(PrefsPort->mp_SigTask,1L << PrefsPort->mp_SigBit);
  127.   Permit();
  128.  
  129.   /* ...and exit! */
  130.   return(0);
  131.  }
  132.  Permit();
  133.  
  134.  /* Open resources */
  135.  if (OpenResources()) {
  136.   /* Check OS version */
  137.   if (SysBase->lib_Version>=39)
  138.    OSV39=TRUE;
  139.  
  140.   /* Set defaults */
  141.   FromFileName=PrefsFileName;
  142.   PubScreenName=NULL;
  143.   ProgramName=NULL;
  144.   DefaultFont=FALSE;
  145.  
  146.   /* WB or CLI startup? */
  147.   if (wa) {
  148.    /* WB Startup */
  149.    struct DiskObject *dobj;
  150.  
  151.    /* Get icon */
  152.    if (dobj=GetDiskObjectNew(wa->wa_Name)) {
  153.     char *s,**tt=dobj->do_ToolTypes;
  154.  
  155.     /* USE? */
  156.     if (FindToolType(tt,"USE")) {
  157.      /* Copy From file to preferences file */
  158.      CopyFile(wa->wa_Name,PrefsFileName);
  159.  
  160.      /* ...and exit */
  161.      FreeDiskObject(dobj);
  162.      CloseResources();
  163.      return(0);
  164.     }
  165.  
  166.     /* SAVE? */
  167.     if (FindToolType(tt,"SAVE")) {
  168.      /* Copy From file to preferences file */
  169.      CopyFile(wa->wa_Name,SavePrefsFileName);
  170.  
  171.      /* ...and exit */
  172.      FreeDiskObject(dobj);
  173.      CloseResources();
  174.      return(0);
  175.     }
  176.  
  177.     /* PUBSCREEN */
  178.     if (s=FindToolType(tt,"PUBSCREEN")) PubScreenName=strdup(s);
  179.  
  180.     /* DEFAULTFONT */
  181.     if (s=FindToolType(tt,"DEFAULTFONT"))
  182.      DefaultFont=MatchToolValue(YesString,s);
  183.  
  184.     /* CREATEICONS */
  185.     if (s=FindToolType(tt,"CREATEICONS"))
  186.      CreateIcons=MatchToolValue(YesString,s);
  187.  
  188.     /* XPOS */
  189.     if (s=FindToolType(tt,"XPOS"))
  190.      MainWinX=strtol(s,NULL,10);
  191.  
  192.     /* YPOS */
  193.     if (s=FindToolType(tt,"YPOS"))
  194.      MainWinY=strtol(s,NULL,10);
  195.  
  196.     /* LISTCOLUMNS */
  197.     if (s=FindToolType(tt,"MINLISTCOLUMNS"))
  198.      if ((ListViewColumns=strtol(s,NULL,10))<20)
  199.       ListViewColumns=20;
  200.  
  201.     /* LISTROWS */
  202.     if (s=FindToolType(tt,"MINLISTROWS"))
  203.      if ((ListViewRows=strtol(s,NULL,10))<8)
  204.       ListViewRows=8;
  205.  
  206.     /* Get program & prefs file name. Icon type? */
  207.     switch (dobj->do_Type) {
  208.      case WBTOOL:    if (ProgramName=malloc(256)) {
  209.                       *ProgramName='\0';
  210.                       if (NameFromLock(wa->wa_Lock,ProgramName,256))
  211.                        AddPart(ProgramName,wa->wa_Name,256);
  212.                      }
  213.                      break;
  214.      case WBPROJECT: ProgramName=strdup(dobj->do_DefaultTool);
  215.                      if (!(FromFileName=strdup(wa->wa_Name)))
  216.                       FromFileName=PrefsFileName;
  217.                      break;
  218.     }
  219.  
  220.     /* Free DiskObject */
  221.     FreeDiskObject(dobj);
  222.    }
  223.   } else {
  224.    /* CLI Startup */
  225.    struct RDArgs *rda;
  226.  
  227.    /* Parse command line */
  228.    rda=ReadArgs(Template,(LONG *) &cmdlineparams,NULL);
  229.  
  230.    /* Get values */
  231.    if (cmdlineparams.from) FromFileName=strdup(cmdlineparams.from);
  232.    if (!FromFileName) FromFileName=PrefsFileName;
  233.    if (cmdlineparams.pubsc) PubScreenName=strdup(cmdlineparams.pubsc);
  234.    if (cmdlineparams.deffont) DefaultFont=TRUE;
  235.  
  236.    /* Free ReadArgs parameters */
  237.    if (rda) FreeArgs(rda);
  238.  
  239.    /* USE? */
  240.    if (cmdlineparams.use) {
  241.     /* Copy From file to preferences file */
  242.     CopyFile(FromFileName,PrefsFileName);
  243.  
  244.     /* ...and exit */
  245.     CloseResources();
  246.     return(0);
  247.    }
  248.  
  249.    /* SAVE? */
  250.    if (cmdlineparams.save) {
  251.     /* Copy From file to save preferences file */
  252.     CopyFile(FromFileName,SavePrefsFileName);
  253.  
  254.     /* ...and exit */
  255.     CloseResources();
  256.     return(0);
  257.    }
  258.  
  259.    /* Get program name */
  260.    if (ProgramName=malloc(256)) {
  261.     *ProgramName='\0';
  262.     GetProgramName(ProgramName,256);
  263.    }
  264.   }
  265.  
  266.   /* Init object lists */
  267.   {
  268.    int i;
  269.  
  270.    for (i=0; i<TMOBJTYPES; i++) NewList(&ObjectLists[i]);
  271.   }
  272.  
  273.   /* Read public screen list */
  274.   NewList(&PubScreenList);
  275.   {
  276.    struct List *pubsclist;
  277.  
  278.    if (pubsclist=LockPubScreenList()) {
  279.     struct PubScreenNode *pubscnode=GetHead(pubsclist);
  280.  
  281.     /* Scan list */
  282.     while (pubscnode) {
  283.      struct Node *mynode;
  284.  
  285.      /* Copy entry */
  286.      if (mynode=malloc(sizeof(struct Node)))
  287.       if (mynode->ln_Name=strdup(pubscnode->psn_Node.ln_Name))
  288.        /* Node allocated, add it to list */
  289.        AddTail(&PubScreenList,mynode);
  290.       else
  291.        /* no memory, free node */
  292.        free(mynode);
  293.  
  294.      /* get a pointer to next node */
  295.      pubscnode=GetSucc(pubscnode);
  296.     }
  297.  
  298.     /* Release public screen list */
  299.     UnlockPubScreenList();
  300.    }
  301.   }
  302.  
  303.   /* Try to get the Workbench window offsets */
  304.   if (PublicScreen=LockPubScreen(WBName)) {
  305.    struct Window *w=PublicScreen->FirstWindow;
  306.  
  307.    /* Scan Workbench screen window list */
  308.    while (w) {
  309.     struct MsgPort *mp=w->UserPort;
  310.  
  311.     /* Workbench window? (Lots of safety checks) */
  312.     if ((w->Flags & WFLG_WBENCHWINDOW) && mp &&
  313.         ((mp->mp_Flags & PF_ACTION) == PA_SIGNAL)) {
  314.      struct Task *t=mp->mp_SigTask;
  315.  
  316.      /* More safety checks */
  317.      if (t && t->tc_Node.ln_Name && !strcmp(t->tc_Node.ln_Name,WBName))
  318.       /* Window title valid? */
  319.       if (w->Title) {
  320.        /* Window has title, compare it to string "Workbench" */
  321.        if (!strcmp(w->Title,WBName)) break;
  322.       } else
  323.        /* Window has no title, check for Workbench backdrop window */
  324.        if ((w->Flags & (WFLG_BACKDROP|WFLG_BORDERLESS)) ==
  325.             (WFLG_BACKDROP|WFLG_BORDERLESS))
  326.         break;
  327.     }
  328.  
  329.     /* next window */
  330.     w=w->NextWindow;
  331.    }
  332.  
  333.    /* Window found? */
  334.    if (w)
  335.     /* Yes. Read offsets. Backdrop window? */
  336.     if (w->Flags & WFLG_BACKDROP) {
  337.      /* Yes. Just read window coordinates */
  338.      WBXOffset=w->LeftEdge;
  339.      WBYOffset=w->TopEdge;
  340.     } else {
  341.      /* No */
  342.      WBXOffset=w->LeftEdge+w->BorderLeft;
  343.      WBYOffset=w->TopEdge+w->BorderTop;
  344.     }
  345.  
  346.    UnlockPubScreen(NULL,PublicScreen);
  347.   }
  348.  
  349.   /* Read Configuration */
  350.   if (ReadConfigFile(FromFileName)) {
  351.    /* Lock default public screen */
  352.    if (PublicScreen=LockPubScreen(PubScreenName)) {
  353.     WBScreen=(PublicScreen->Flags & SCREENTYPE) == WBENCHSCREEN;
  354.  
  355.     /* Get visual info */
  356.     if (ScreenVI=GetVisualInfo(PublicScreen,TAG_DONE)) {
  357.      /* Which font should be used? */
  358.      if (DefaultFont) {
  359.       struct TextFont *tf=GfxBase->DefaultFont;
  360.  
  361.       /* Read system default font values */
  362.       ScreenTextAttr.ta_Name=tf->tf_Message.mn_Node.ln_Name;
  363.       ScreenTextAttr.ta_YSize=tf->tf_YSize;
  364.       ScreenTextAttr.ta_Style=tf->tf_Style;
  365.       ScreenTextAttr.ta_Flags=tf->tf_Flags;
  366.      }
  367.      else
  368.       /* Copy public screen TextAttr */
  369.       ScreenTextAttr=*(PublicScreen->Font);
  370.  
  371.      /* Limit font size. Fonts must be higher than 7 pixels! */
  372.      if (ScreenTextAttr.ta_YSize<8) ScreenTextAttr.ta_YSize=8;
  373.  
  374.      /* Open screen font */
  375.      if (ScreenFont=OpenDiskFont(&ScreenTextAttr)) {
  376.  
  377.       /* Calculate requester button image */
  378.       if (CalcReqButtonImage()) {
  379.        ULONG IDCMPSignalMask;
  380.  
  381.        /* Init global TmpRastPort */
  382.        InitRastPort(&TmpRastPort);
  383.        SetFont(&TmpRastPort,ScreenFont);
  384.  
  385.        /* Init windows */
  386.        {
  387.         UWORD left=PublicScreen->WBorLeft+INTERWIDTH/2;
  388.         UWORD fheight=ScreenFont->tf_YSize+INTERHEIGHT;
  389.  
  390.         WindowTop=PublicScreen->WBorTop+PublicScreen->Font->ta_YSize+1;
  391.  
  392.         InitMainWindow(left,fheight);
  393.         InitExecEditWindow(left,fheight);
  394.         InitImageEditWindow(left,fheight);
  395.         InitSoundEditWindow(left,fheight);
  396.         InitMenuEditWindow(left,fheight);
  397.         InitIconEditWindow(left,fheight);
  398.         InitDockEditWindow(left,fheight);
  399.         InitAccessEditWindow(left,fheight);
  400.         InitSelectWindow(left,fheight);
  401.         InitMoveWindow(left,fheight);
  402.         InitDockListEditWindow(left,fheight);
  403.         InitListRequester(left,fheight);
  404.        }
  405.  
  406.        /* Init global NewGadget structure */
  407.        NewGadget.ng_TextAttr=&ScreenTextAttr;
  408.        NewGadget.ng_VisualInfo=ScreenVI;
  409.        NewGadget.ng_UserData=NULL;
  410.  
  411.        /* Open main window */
  412.        if (IDCMPSignalMask=OpenMainWindow(MainWinX,MainWinY)) {
  413.         ULONG PrefsPortSignalMask,AppMsgPortSignalMask,SignalMask;
  414.         BPTR oldcd;
  415.         BOOL notend=TRUE;
  416.  
  417.         /* Init signal masks */
  418.         PrefsPortSignalMask=1L << PrefsPort->mp_SigBit;
  419.         AppMsgPortSignalMask=1L << AppMsgPort->mp_SigBit;
  420.         SignalMask=IDCMPSignalMask | PrefsPortSignalMask |
  421.                     AppMsgPortSignalMask;
  422.  
  423.         /* Go to boot directory */
  424.         oldcd=CurrentDir(NULL);
  425.  
  426.         /* Main event loop */
  427.         while (notend) {
  428.          ULONG GotSigs;
  429.  
  430. /*         DEBUG_PRINTF("CONF: Waiting for messages...\n"); */
  431.  
  432.          /* Wait for messages */
  433.          GotSigs=Wait(SignalMask);
  434.  
  435.          /* IDCMP Event? */
  436.          if (GotSigs & IDCMPSignalMask) {
  437.           struct IntuiMessage *msg;
  438.  
  439.           /* Scan IDCMP port */
  440.           while (msg=GT_GetIMsg(IDCMPPort)) {
  441.            void *data;
  442.            HandleIDCMPFuncPtr func=(HandleIDCMPFuncPtr)
  443.                                     msg->IDCMPWindow->UserData;
  444.  
  445.            /* Handle IDCMP Message. Window closed? */
  446.            if (data=(*func)(msg))
  447.             /* Yes. Main window closed? */
  448.             if (UpdateWindow)
  449.              /* No, call update function */
  450.              (*UpdateWindow)(data);
  451.             else
  452.              /* Yes, quit program */
  453.              notend=FALSE;
  454.            else
  455.             /* No, reply message */
  456.             GT_ReplyIMsg(msg);
  457.           }
  458.          }
  459.  
  460.          /* Prefs port signal? */
  461.          if (GotSigs & PrefsPortSignalMask)
  462.           /* Yes. Move current window to front */
  463.           WindowToFront(CurrentWindow);
  464.  
  465.          /* Application message arrived? */
  466.          if (GotSigs & AppMsgPortSignalMask) {
  467.           struct AppMessage *msg;
  468.  
  469.           /* Scan AppMsg port */
  470.           while (msg=(struct AppMessage *) GetMsg(AppMsgPort)) {
  471.            /* Application message handling function valid? */
  472.            if (HandleAppMsg)
  473.             /* Yes, handle message */
  474.             (*HandleAppMsg)(msg);
  475.  
  476.            /* Reply message */
  477.            ReplyMsg((struct Message *) msg);
  478.           }
  479.          }
  480.         }
  481.  
  482.         /* Go back to old directory */
  483.         CurrentDir(oldcd);
  484.  
  485.         /* Close Main Window */
  486.         CloseMainWindow();
  487.  
  488.         /* End of program. Clear public screen pointer */
  489.         PublicScreen=NULL;
  490.        }
  491.        FreeReqButtonImage();
  492.       }
  493.       CloseFont(ScreenFont);
  494.      }
  495.      FreeVisualInfo(ScreenVI);
  496.     }
  497.     if (PublicScreen) UnlockPubScreen(NULL,PublicScreen);
  498.    }
  499.   }
  500.  
  501.   /* Free public screen list */
  502.   {
  503.    struct Node *n1,*n2=GetHead(&PubScreenList);
  504.  
  505.    while (n1=n2) {
  506.     /* Get next node */
  507.     n2=GetSucc(n1);
  508.  
  509.     /* Free node */
  510.     free(n1->ln_Name);
  511.     free(n1);
  512.    }
  513.   }
  514.  
  515.   /* Free all object nodes */
  516.   FreeAllObjects();
  517.  }
  518.  
  519.  /* Closing down... */
  520.  CloseResources();
  521.  return(0);
  522. }
  523.  
  524. /* CLI entry point */
  525. int main(int argc, char *argv[])
  526. {
  527.  return(mainprogram(NULL));
  528. }
  529.  
  530. /* WB entry point */
  531. int wbmain(struct WBStartup *wbs)
  532. {
  533.  struct WBArg *wa;
  534.  BPTR dirlock;
  535.  int rc;
  536.  
  537.  /* Get last WBArg */
  538.  wa=&wbs->sm_ArgList[wbs->sm_NumArgs-1];
  539.  
  540.  /* Go to icon directory */
  541.  dirlock=CurrentDir(wa->wa_Lock);
  542.  
  543.  /* Do it :-) */
  544.  rc=mainprogram(wa);
  545.  
  546.  /* Go back... */
  547.  CurrentDir(dirlock);
  548.  return(rc);
  549. }
  550.